package cc.loac.heba.service;

import cc.loac.heba.dao.CommentDao;
import cc.loac.heba.pojo.Comment;
import cc.loac.heba.pojo.Hei;
import cc.loac.heba.pojo.Message;
import cc.loac.heba.pojo.Result;
import cc.loac.heba.tool.Common;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class CommentService {

    @Resource
    CommentDao commentDao;

    @Resource
    LoginTokenService loginTokenService;

    @Resource
    HeiService heiService;

    @Resource
    MessageService messageService;

    /**
     * 根据嘿文 ID 获取评论
     * @param heiId 嘿文 ID
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    public String getCommentByHeiId(String heiId, String email, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            if (heiId.equals("undefined")) {
                return Common.toJson(result);
            }
            // 获取指定嘿文 ID 的所有评论
            List<Comment> comments = commentDao.selectCommentByHeiId(Integer.parseInt(heiId));

            // 将子评论加入父评论的 children 参数中
            List<Comment> resultList = new ArrayList<>();
            while (comments.size() != 0) {
                Comment comment = comments.get(0);
                List<Comment> children = new ArrayList<>();
                // 寻找当前评论是否有子评论
                for (int i = 0; i < comments.size(); i++) {
                    if (comments.get(i).getParentCommentId() != null && comments.get(i).getParentCommentId().equals(comment.getCommentId())) {
                        // 将当前评论加入父评论的 children
                        children.add(comments.get(i));
                        // 删除 comments 中当前评论
                        comments.remove(i);
                        i--;
                    }
                }
                comment.setChildren(children);
                resultList.add(comment);
                comments.remove(0);
            }
            result.setContent(resultList);
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }


    /**
     * 检查 Token 是否不存在或者过期
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    private Result tokenIsExpired(String email, String token) {
        // 未传入 token
        if (token == null) {
            return Common.tokenIsNull();
        }
        Result tokenResult = loginTokenService.checkToken(email, token);
        if (tokenResult.getStatus() != 0) {
            // Token 已经过期
            return tokenResult;
        }
        return new Result();
    }

    /**
     * 添加评论
     * @param heiId 嘿文 ID
     * @param email 邮箱
     * @param content 评论内容
     * @param parentId 父评论 ID
     * @param replyId 回复评论 ID
     * @param token Token
     * @return Result
     */
    public String addComment(String heiId, String email, String content, String parentId, String replyId, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            if (parentId == null && replyId != null) {
                result.setStatus(-2);
                result.setMessage("未指定 parentId，所以无法设置 relyId");
                return Common.toJson(result);
            }

            Comment comment = new Comment();
            comment.setHeiId(Integer.parseInt(heiId));
            comment.setEmail(email);
            comment.setContent(content);
            comment.setParentCommentId(parentId == null || parentId.equals("") ? null : Integer.parseInt(parentId));
            comment.setReplyCommentId(replyId == null || replyId.equals("") ? null : Integer.parseInt(replyId));
            comment.setCreateTime(new Date());

            // 插入数据库
            commentDao.insertComment(comment);

            // 单独线程处理其他数据
            new Thread(() -> {
                // 刷新嘿文评论数量
                heiService.updateHeiCommentCountByHeiId(Integer.parseInt(heiId));

                // 给评论回复的对象发送消息
                if (parentId == null || parentId.equals("")) {
                    // 没有父评论 ID，是给嘿文评论，给嘿文发布者发送消息
                    Hei hei = heiService.heiDao.selectHeiById(heiId);
                    // 如果是给自己评论就不发送消息
                    if (!email.equals(hei.getEmail())) {
                        messageService.addMessage(email, hei.getEmail(), Message.TYPE_COMMENT, heiId);
                    }
                    return;
                }

                Comment comm;
                if (replyId == null || replyId.equals("")) {
                    // 父评论不为空，但回复的评论为空，给父评论者发送消息
                    comm = commentDao.selectCommentByCommentId(Integer.parseInt(parentId));
                } else {
                    // 父评论不为空，且回复的评论不为空，给回复评论者发送消息
                    comm = commentDao.selectCommentByCommentId(Integer.parseInt(replyId));
                }
                // 如果 comm 为空或者是给自己评论回复就不发送消息
                if (comm != null && !email.equals(comm.getEmail())) {
                    // 发送消息
                    messageService.addMessage(email, comm.getEmail(), Message.TYPE_REPLY, comm.getHeiId().toString());
                }
            }).start();

            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }

    /**
     * 删除评论
     * @param commentId 评论 ID
     * @param email 邮箱
     * @param token Token
     * @return Result
     */
    public String deleteComment(String commentId, String email, String token) {
        Result result;
        try {
            result = tokenIsExpired(email, token);
            if (result.getStatus() != 0) {
                // Token 有问题，返回原因
                return Common.toJson(result);
            }

            Comment comment = commentDao.selectCommentByCommentIdAndEmail(Integer.parseInt(commentId), email);

            if (comment == null) {
                result.setContent("评论不存在");
                result.setStatus(-2);
                return Common.toJson(result);
            }

            // 删除评论
            commentDao.deleteCommentById(Integer.parseInt(commentId));


            // 单独线程处理其他数据
            new Thread(() -> {
                // 如果当前删除的评论没有父评论，那有可能是顶层评论，尝试删除当前评论的所有子评论
                if (comment.getParentCommentId() == null || comment.getParentCommentId() == 0) {
                    commentDao.deleteCommentByParentId(comment.getCommentId());
                }

                // 刷新嘿文评论数量
                heiService.updateHeiCommentCountByHeiId(comment.getHeiId());
            }).start();
            return Common.toJson(result);
        } catch (Exception e) {
            e.printStackTrace();
            return Common.exceptionResults();
        }
    }
}
